home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 January / enter-2004-01.iso / files / maxima-5.9.0.exe / {app} / share / maxima / 5.9.0 / src / series.lisp < prev    next >
Encoding:
Text File  |  2003-02-09  |  18.1 KB  |  594 lines

  1. ;;; -*-  Mode: Lisp; Package: Maxima; Syntax: Common-Lisp; Base: 10 -*- ;;;;
  2. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  3. ;;;     The data in this file contains enhancments.                    ;;;;;
  4. ;;;                                                                    ;;;;;
  5. ;;;  Copyright (c) 1984,1987 by William Schelter,University of Texas   ;;;;;
  6. ;;;     All rights reserved                                            ;;;;;
  7. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  8. ;;;     (c) Copyright 1982 Massachusetts Institute of Technology         ;;;
  9. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  10.  
  11. (in-package "MAXIMA")
  12. (macsyma-module series)
  13.  
  14. (declare-top (genprefix ps)
  15.      (*lexpr factor $gcd $rat)
  16.      (fixnum %n %nn)
  17.      (special var *n *a *m *c *index $cauchysum *gcd*
  18.           nn* dn* $ratsimpexpons *infsumsimp
  19.           *ratexp splist *var usexp $verbose ans *trigred
  20.           *form indl *noexpand $ratexpand))
  21.  
  22. (load-macsyma-macros rzmac)
  23.  
  24. ;
  25. ;******************************************************************************
  26. ;                driver     stage
  27. ;******************************************************************************
  28. ;
  29. ;        the following throw labels are used
  30. ;
  31. ;psex -- for throws on failure to expand
  32. ;
  33.  
  34. (defmfun $powerseries (l var *pt)
  35.     (cond ((signp e *pt)
  36.            (cond ((symbolp var) (seriesexpand* l))
  37.              ((numberp var) (improper-arg-err var '$powerseries))
  38.              (t (sbstpt l 'x (gensym) var var))))
  39.           ((eq *pt '$inf)
  40.            (sbstpt l (m// 1 'x) (gensym) var (div* 1 var)))
  41.           (t (sbstpt l (m+ 'x *pt) (gensym)
  42.              var (simplifya (m- var *pt) nil)))))
  43.  
  44. (defun sbstpt (exp sexp var var1 usexp)
  45.     (setq sexp (subst var 'x sexp))
  46.     (setq exp (MAXIMA-SUBSTITUTE sexp var1 exp))
  47.     (MAXIMA-SUBSTITUTE usexp var (seriesexpand* exp)))
  48.  
  49. (defun seriesexpand* (x)
  50.   (let (*n *a *m *c
  51.        (*index (gensumindex))
  52.        ($cauchysum t)
  53.        ($ratsimpexpons t) $ratexpand
  54.        *infsumsimp *ratexp *trigred *noexpand)
  55.        (mkind *index '$integer)
  56.        (setq x (catch 'psex (sp2expand (seriespass1 x))))
  57.        (cond ((and x (atom x)) x)
  58.          ((and x (not (eq (car x) 'err))) x)
  59.          ($verbose
  60.           (mtell "Unable to expand for the following reason:")
  61.           (cond ((null x) (mtell "~%no reason given") '|&Unable to expand|)
  62.             (t (cdr x))))
  63.          (t '|&Unable to expand|))))
  64.  
  65. (defun out-of (e)
  66.   (let  ((e      (cond ((and (boundp '*var) *var)
  67.             (subst (list '(mexpt) *var *gcd*) var e))
  68.                (t e)))
  69.      (var      (cond ((and (boundp '*var) *var)) (t var))))
  70.     (cond ((and (boundp 'usexp) usexp)
  71.        (subst usexp var e))
  72.       (t e))))
  73.  
  74. (defun show-exp (e)
  75.   (mtell "~%~%~M~%~%"
  76.      (list '(mlable) nil (out-of e))))
  77.  
  78. (defun seriespass1 (e)
  79.   (let ((w (sratsimp (sp1 e))))
  80.        (when $verbose
  81.          (terpri)
  82.          (mtell "In the first simplification we have returned:")
  83.          (show-exp w))
  84.        w))
  85.  
  86. ;
  87. ;*****************************************************************************
  88. ;    pass two        expansion phase
  89. ;*****************************************************************************
  90. ;
  91.  
  92. (defun sp2expand (exp)
  93.     (cond ((or (free exp var) (atom exp)) exp)
  94.       ((mbagp exp) (cons (car exp) (mapcar #'sp2expand (cdr exp))))
  95.       ((sratp exp var) (ratexp exp))
  96.       ((eq (caar exp) 'mexpt) (sp2expt exp))
  97.       ((oldget (caar exp) 'sp2) (sp2sub (sp2trig exp) (cadr exp)))
  98.       ((poly? exp var) exp)
  99.       ((eq (caar exp) 'mtimes) (m*l (mapcar #'sp2expand (cdr exp))))
  100.       ((eq (caar exp) 'mplus) (m+l (mapcar #'sp2expand (cdr exp))))
  101.       ((eq (caar exp) '%log) (sp2log (cadr exp)))
  102.       ((eq (caar exp) '%derivative) (sp2diff (cadr exp) (cddr exp)))
  103.       ((eq (caar exp) '%integrate)
  104.        (sp2integ (cadr exp) (caddr exp) (cdddr exp)))
  105.       ((memq (caar exp) '(%product %sum))
  106.        (list* (car exp) (sp2expand (cadr exp)) (cddr exp)))
  107.       (t (list '(%sum)
  108.            (m* (m^ var *index)
  109.                (m^ (list '(mfactorial) *index) -1)
  110.                (list '(%at) (list '(%derivative) exp var *index)
  111.                  (list '(mequal) var 0)))
  112.            *index 0 '$inf))))
  113.  
  114. (defun sp2sub (s exp)
  115.   (cond ((smono exp var) (MAXIMA-SUBSTITUTE exp 'sp2var (simplify s)))
  116.     (t (throw 'psex (list 'err '(mtext)
  117.                    "Tried to MAXIMA-SUBSTITUTE the expansion of  "
  118.                    (out-of exp)
  119.                    " into an expansion")))))
  120.  
  121. (defun ratexp (exp)
  122.   (let (nn* dn* *gcd*)
  123.        (if $verbose
  124.        (mtell "trying to do a rational function expansion of~%~M"
  125.           (list '(mlable) nil exp)))
  126.        (numden exp)
  127.        (sratexpnd nn* dn*)))
  128.  
  129. (defun sratexpnd (n d)
  130.     (let ((ans (list nil))
  131.       (splist)
  132.       (linpat
  133.        '((mtimes) ((coefftt) (cc not-zero-free var))
  134.               ((mexpt) ((mplus) ((coeffpt) 
  135.                      (w m1 ((mexpt) (x equal var)
  136.                             (m not-zero-free var)))
  137.                      (c freevar))
  138.                     ((coeffpp) (a freevar)))
  139.                    (n not-zero-free var)))))
  140.     (cond ((and (not (equal n 1)) (smono n var))
  141.            (m* n (sratexpnd 1 d)))
  142.           ((free d var)
  143.            (cond ((poly? n var)
  144.               (m// n d))
  145.              ((m1 n linpat)
  146.               (m* (srbinexpnd (cdr ans)) (div* 1 d)))
  147.              ((throw 'psex nil))))
  148.           ((smonop d var)
  149.            (cond ((mplusp n)
  150.               (m+l (mapcar #'(lambda (q) (div* q d)) (cdr n))))
  151.              (t (m// n d))))
  152.           ((not (equal 1 (setq *gcd* (ggcd (nconc (exlist n) (exlist d))))))
  153.            (sratsubst *gcd* n d))
  154.           ((and (equal n 1)
  155.             (prog2 (setq d (let (($ratfac t))
  156.                     (ratdisrep ($rat (factor d) var))))
  157.                (m1 d linpat)))
  158.            (m// (srbinexpnd (cdr ans)) (cdr (assq 'cc (cdr ans)))))
  159.           (t
  160.            (and *ratexp (throw 'psex nil))
  161.            (if (not (eq (caar d) 'mtimes)) (ratexand1 n d))
  162.            (do ((p (cdr d) (cdr p)))
  163.            ((null p) (ratexand1 n d))
  164.            (cond ((or (eq (car p) var)
  165.                   (and (mexptp (car p)) (eq (cadaar p) var)))
  166.                (return (m* (sratexpnd n (meval (div* d (car p))))
  167.                       (list '(mexpt) (car p) -1))))))))))
  168.  
  169. (defun ratexand1 (n d)
  170.     (and $verbose
  171.      (prog2 (mtell "Trying partial fraction expansion of ")
  172.         (show-exp (list '(mquotient) n d))
  173.         (terpri)))
  174.   (funcall #'(lambda (*ratexp) 
  175.     (m+l (mapcar #'ratexp
  176.          (funcall #'(lambda (l)
  177.               (cond ((eq (caar l) 'mplus)
  178.                  (and $verbose
  179.                       (mtell "which is ")
  180.                       (show-exp l))
  181.                  (cdr l))
  182.                 (t (throw 'psex
  183.                        '(err (mtext)
  184.                          "Partial fraction expansion failed")))))
  185.           ($partfrac (div* n d) var)))))
  186.    t))
  187.  
  188. (defun sratsubst (gcd num den)
  189.     (and $verbose
  190.      (prog2 (mtell "We are substituting for the occurrences of")
  191.         (show-exp (list '(mexpt) var gcd))
  192.         (mtell "in")
  193.          (show-exp (list '(mquotient) num den))
  194.         (terpri)))
  195.     (funcall #'(lambda (var* *var)
  196.     (setq num (MAXIMA-SUBSTITUTE (m^ var* (m^ gcd -1)) *var num)
  197.           den (MAXIMA-SUBSTITUTE (m^ var* (m^ gcd -1)) *var den))
  198.     (MAXIMA-SUBSTITUTE (m^ *var gcd) var*
  199.             (funcall #'(lambda (var) (sratexpnd num den)) var*)))
  200.      (gensym) var))
  201.  
  202. (defun ggcd (l)
  203.     (cond ((null l) 1)
  204.           ((null (cdr l)) (car l))
  205.           ((equal 1 (car l)) 1)
  206.           (t ($gcd (ggcd (cdr l)) (car l)))))
  207.  
  208. (defun exlist (exp)
  209.     (cond ((null exp) nil)
  210.           ((atom exp)
  211.            (and (eq exp var) (ncons 1)))
  212.           ((and (not (atom (car exp))) (eq (caar exp) 'mplus))
  213.            (exlist (cdr exp)))
  214.           ((smono (car exp) var)
  215.            (cond ((equal *n 0) (exlist (cdr exp)))
  216.              (t (cons *n (exlist (cdr exp))))))
  217.           (t (exlist (cdr exp)))))
  218.  
  219. (defun srbinexpnd (ans)
  220.     (let ((n (cdr (assq 'n ans)))
  221.       (a (cdr (assq 'a ans)))
  222.       (m (cdr (assq 'm ans)))
  223.       (c (cdr (assq 'c ans))))
  224.     (cond ((integerp n) (srintegexpd n a m c))
  225.           (t (list '(%sum)
  226.                (m// (m* (m^ (m* c var) (m* m *index))
  227.                 (m^ a (m- n *index)))
  228.                 (m* (list '($beta) (m- n (m1- *index)) (m1+ *index))
  229.                 (m1+ n)))
  230.                *index 0 '$inf)))))
  231.  
  232. (defun psp2form (coeff exp bas)
  233.     (list '(%sum) (m* coeff (m^ var exp)) *index bas '$inf))
  234.  
  235. (defun srintegexpd (n a m c)
  236.     (and $verbose
  237.      (prog2 (mtell "Using a special rule for expressions of form ")
  238.         (show-exp '((mexpt) ((mplus) $a ((mtimes) $c ((mexpt) $var $m)))
  239.                     ((mminus) $n)))
  240.         (mtell "Here we have")
  241.         (show-exp (list '(mlist) (list '(mequal) '$n n) (list '(mequal) '$a a)
  242.                      (list '(mequal) '$c c) (list '(mequal) '$m m)))))
  243.     (cond ((= n 1)
  244.        (psp2form
  245.         (m* (m^ a (m* -1 (m+ 1 *index)))
  246.         (m^ (m* -1 c) *index))
  247.         (if (equal m 1) *index (m* *index m))
  248.         0))
  249.       ((= 2 n)
  250.        (psp2form (m* (m+ 1 *index)
  251.              (m^ c (m* -1 (m+ 2 *index)))
  252.              (m^ (m* -1 a) *index))
  253.              (if (equal m 1) *index (m* *index m))
  254.              0))
  255.       (t (psp2form (m* (do ((nn (f1- n) (f1- nn))
  256.                 (l nil (cons (list '(mplus) *index nn) l)))
  257.                    ((= nn 0)
  258.                 (m*l (cons (m// 1 (factorial (f1- n))) l))))
  259.                (m^ (m* -1 c (m^ a -1)) *index)
  260.                (m^ a (f- n)))
  261.                (if (equal m 1) *index (m* *index m))
  262.                0))))
  263.  
  264. (defun sratp (a var)
  265.     (cond ((atom a) t)
  266.           ((memq (caar a) '(mplus mtimes)) (sandmap (cdr a)))
  267.           ((eq (caar a) 'mexpt)
  268.            (cond ((free (cadr a) var) (free (caddr a) var))
  269.              ((smono a var) t)
  270.              ((and (free (caddr a) var) (sratp (cadr a) var)))))
  271.           (t (free (cadr a) var))))
  272.  
  273. (defun sandmap (l) (or (null l) (and (sratp (car l) var) (sandmap (cdr l)))))
  274.  
  275. (defun sp2trig (exp) (subst *index '*index (oldget (caar exp) 'sp2)))
  276.  
  277. (defun sp2log (e)
  278.     (funcall #'(lambda (exp *a *n)
  279.     (cond ((or (atom e) (free e var)) (list '(%log) e))
  280.           ((null (smono exp var)) (throw 'psex nil))
  281.           ((or (and (numberp *a)
  282.             (minusp *a)
  283.             (setq *a (minus *a)))
  284.            (and (mtimesp *a)
  285.             (numberp (cadr *a))
  286.             (minusp (cadr *a))
  287.             (setq *a (simptimes
  288.                    (list* (car *a) (minus (cadr *a)) (cddr *a))
  289.                    1 t))))
  290.            (list '(%sum)
  291.              (m* -1
  292.              (m^ (m* (m^ var *n) *a) *index)
  293.              (m^ *index -1))
  294.              *index 1 '$inf))
  295.           (t (list '(%sum)
  296.                (m* -1
  297.                (m^ (m* -1 *a (m^ var *n)) *index)
  298.                (m^ *index -1))
  299.                *index 1 '$inf))))
  300.      (m- e 1) nil nil))
  301.  
  302. (defun sp2expt (exp)
  303.        (cond ((and (numberp (caddr exp)) (mexptp (cadr exp)))
  304.           (sp2expt (m^ (cadr (cadr exp))
  305.                (m* (caddr exp) (caddr (cadr exp))))))
  306.          ((and (free (caddr exp) var)
  307.            (signp g (caddr exp))
  308.            (lessp (caddr exp) $maxposex))
  309.           (m*l (dup (sp2expand (cadr exp)) (caddr exp))))
  310.          ((free (cadr exp) var)
  311.           (sp2sub (subst *index
  312.                  '*index
  313.                  (subst (cond ((eq (cadr exp) '$%e) 'sp2var)
  314.                       (t (list '(mtimes)
  315.                            (list '(mlog) (cadr exp))
  316.                            'sp2var)))
  317.                     'sp2var
  318.                     (get 'mexpt 'sp2)))
  319.               (caddr exp)))
  320.          (t (throw 'psex nil))))
  321.  
  322. (defun dup (x %n) (if (= %n 1) (ncons x) (cons x (dup x (f1- %n)))))
  323.  
  324. (defun sp2diff (exp l)
  325.   (let (indl)
  326.     (cond ((free exp var)
  327.        (sp3form (sp2expand exp) (cons '(%derivative) l)))
  328.       (t (do ((l l (cddr l)) (ll))
  329.          ((null l)
  330.           (if ll (sp3form exp (cons '(%derivative) (nreverse ll)))
  331.              exp))
  332.          (cond ((eq (car l) var)
  333.             (do ((%i (cadr l) (f1- %i)))
  334.                 ((= %i 0) exp)
  335.                 (setq indl nil
  336.                   exp (sp2diff1 (sp2expand exp) nil nil))))
  337.                (t (setq ll (list* (cadr l) (car l) ll)))))))))
  338.  
  339. (defun sp2diff1 (exp ind lol)    ;ind is a list of the indices
  340.                 ;lol is a list of the lower limits
  341.     (cond ((atom exp) (sdiff exp var))
  342.       ((eq (caar exp) 'mplus)
  343.        (cons '(mplus)
  344.          (mapcar #'(lambda (q) (sp2diff1 q ind lol))
  345.              (cdr exp))))
  346.       ((eq (caar exp) '%sum)
  347.        (setq indl (cons (copy-list (cddr exp)) indl))
  348.        (sp2diff1 (cadr exp)
  349.              (cons (caddr exp) ind)
  350.              (cons (cadddr exp) lol)))
  351.       (t (sp2diff2 exp ind lol))))
  352.  
  353. (defun sp2diff2 (exp ind lol)
  354.     (let (e fr)
  355.     (setq e (m2 exp '((mtimes) ((coefftt) (fr freevar))
  356.                    ((coefftt) (e true)))
  357.             nil)
  358.           fr (cdr (assq 'fr e))
  359.           e  (cdr (assq 'e e)))
  360.     (sp3reconst
  361.      (cond ((and (mexptp e) (eq (cadr e) var))
  362.         (cond ((equal 0 (mbinding (ind lol)
  363.                       (meval (m* fr (caddr e)))))
  364.                (m* (sp3substp1 ind ind (m* fr (caddr e))) e))
  365.               ((mgrp 1 (mbinding (ind lol)
  366.                      (simplify (mevalatoms (caddr e)))))
  367.                (m* fr (caddr e) (m^ (cadr e) (m- (caddr e) 1))))
  368.               (t (sdiff exp var))))
  369.            (t (sdiff exp var))))))
  370.  
  371. (defun sp2integ (exp v l)
  372.     (if (null l)
  373.     (if (eq var v)
  374.         (sp2integ1 ($expand (sp2expand exp)))
  375.         (sp3form (sp2expand exp) (list '(%integrate) v)))
  376.     (sp2integ2 exp v (car l) (cadr l))))
  377.  
  378. (defun sp2integ1 (exp)
  379.   (let (pair)
  380.     (cond ((ratp exp var) (ratint exp var))
  381.       ((eq (caar exp) 'mplus)
  382.        (cons '(mplus) (mapcar #'sp2integ1 (cdr exp))))
  383.       ((and (eq (caar exp) 'mtimes)
  384.         (prog2 (setq pair (partition exp var 1))
  385.                (not (equal (car pair) 1))))
  386.        (mul2* (car pair) (sp2integ1 (cdr pair))))
  387.       ((and (eq (caar exp) 'mtimes)
  388.         (prog2 (setq exp ($intosum exp)) nil)))
  389.       ((or (not (eq (caar exp) '%sum)) (not (isinop (cadr exp) '%sum)))
  390.        (sinint exp var))
  391.       (t (let ((indl (ncons (cddr exp))))
  392.            (sp2integ12 (cadr exp) (ncons (caddr exp)) (ncons (cadddr exp))))))))
  393.  
  394. (defun sp2integ12 (exp ind lol)
  395.     (cond ((atom exp)
  396.        (sp3reconst (ratint exp var)))
  397.       ((eq (caar exp) 'mplus)
  398.        (sp3reconst
  399.         (m+l (mapcar #'(lambda (q) (sp2integ13 q ind lol))
  400.                  (cdr exp)))))
  401.       ((eq (caar exp) '%sum)
  402.        (setq indl (cons (cddr exp) indl))
  403.        (sp2integ12 (cadr exp)
  404.                (cons (caddr exp) ind)
  405.                (cons (cadddr exp) lol)))
  406.       (t (sp3reconst (sp2integ13 exp ind lol)))))
  407.  
  408. (defun sp2integ13 (exp ind lol)
  409.     (let (e fr)
  410.     (setq e (m2 exp '((mtimes) ((coefftt) (fr freevar))
  411.                    ((coefftt) (e true)))
  412.             nil)
  413.           fr (cdr (assq 'fr e))
  414.           e  (cdr (assq 'e e)))
  415.     (cond ((and (mexptp e) (eq (cadr e) var))
  416.            (cond ((mgrp -1 (mbinding (ind lol)
  417.                      (meval (caddr e))))
  418.               (m* (sp3substpn ind ind (m* fr (caddr e)) -1) e))
  419.              (t (sinint exp var))))
  420.           (t (sinint exp var)))))
  421.  
  422. (defun sp2integ2 (exp v lo hi)
  423.     (if (eq v var) (setq v (gensym) exp (subst v var exp)))
  424.     (cond ((and (free lo var) (free hi var))
  425.        (cond ((free exp var)
  426.           (list '(%integrate) (subst var v exp) var lo hi))
  427.          (t (sp3form (sp2expand exp)
  428.                  (list '(%integrate) v lo hi)))))
  429.       (t (m+ (sp2sub (setq exp (sp2expand (subst var v exp))) hi)
  430.          (m* -1 (sp2sub exp lo))))))
  431.  
  432. ;
  433. ;************************************************************************************
  434. ;    phase three        miscellaneous garbage and final simplification
  435. ;************************************************************************************
  436. ;
  437.  
  438. (defun sp3reconst (e)
  439.   (do ((l indl (cdr l)) (e e (list* '(%sum) e (car l))))
  440.       ((null l) e)))
  441.  
  442. (defun sp3substpn (vars vals exp n)
  443.   (sp3subst vars (mapcar #'(lambda (q) (add2* q n)) vals) exp))
  444.  
  445. (defun sp3substp1 (vars vals exp) (sp3substpn vars vals exp 1))
  446.  
  447. (defun sp3subst (vars vals exp)
  448.     (simplify (sublis (mapcar #'cons (cdr vars) (cdr vals))
  449.               (subst (car vals) (car vars) exp))))
  450.  
  451. (defun sp3form (e *form) (sp3form1 e))
  452.  
  453. (defun sp3form1 (e)
  454.     (cond ((atom e) (list* (car *form) e (cdr *form)))
  455.       ((eq (caar e) 'mplus)
  456.        (cons '(mplus) (mapcar #'sp3form1 (cdr e))))
  457.       ((eq (caar e) '%sum)
  458.        (list* '(%sum) (sp3form1 (cadr e)) (cddr e)))
  459.       (t (list* (car *form) e (cdr *form)))))
  460.  
  461. ; These are the series expansions for circular functions
  462.  
  463. (defprop %sin
  464.      ((%sum) ((mtimes)
  465.           ((mexpt) -1 *index)
  466.           ((mexpt) ((mfactorial) ((mplus) ((mtimes) 2 *index) 1)) -1)
  467.           ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) 1)))
  468.          *index 0 $inf)
  469.      sp2)
  470.  
  471. (defprop %cos
  472.      ((%sum) ((mtimes) ((mexpt) -1 *index)
  473.                ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  474.                ((mexpt) sp2var ((mtimes) 2 *index)))
  475.          *index 0 $inf)
  476.      sp2)
  477.  
  478. (defprop %tan
  479.      ((%sum) ((mtimes) ((mexpt) -1 ((mplus) *index -1))
  480.                ((mexpt) 2 ((mtimes) 2 *index))
  481.                ((mplus) ((mexpt) 2 ((mtimes) 2 *index)) -1)
  482.                ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  483.                (($bern) ((mtimes) 2 *index))
  484.                ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1)))
  485.          *index 0 $inf)
  486.      sp2)
  487.  
  488. (defprop %csc
  489.      ((%sum) ((mtimes) 2 
  490.           ((mexpt) -1 ((mplus) *index -1))
  491.           ((mplus) ((mexpt) 2 ((mplus) ((mtimes) 2 *index) -1)) -1)
  492.           ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  493.           (($bern) ((mtimes) 2 *index))
  494.           ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1)))
  495.          *index 0 $inf)
  496.      sp2)
  497.  
  498. (defprop %cot
  499.      ((%sum) ((mtimes)
  500.           ((mexpt) -1 *index)
  501.           ((mexpt) 2 ((mtimes) 2 *index))
  502.           ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  503.           (($bern) ((mtimes) 2 *index))
  504.           ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1)))
  505.          *index 0 $inf)
  506.      sp2)
  507.  
  508. (defprop %sec
  509.      ((%sum) ((mtimes) ((mexpt) -1 *index)
  510.                ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  511.                (($euler) ((mtimes) 2 *index))
  512.                ((mexpt) sp2var ((mtimes) 2 *index)))
  513.          *index 0 $inf)
  514.      sp2)
  515.  
  516. ; These are the series definitions of exponential functions.
  517.  
  518. (defprop mexpt
  519.      ((%sum)
  520.       ((mtimes) ((mexpt) ((mfactorial) *index) -1) ((mexpt) sp2var *index))
  521.       *index 0 $inf)
  522.      sp2)
  523.  
  524. (defprop %sinh
  525.      ((%sum) ((mtimes)
  526.           ((mexpt) ((mfactorial) ((mplus) ((mtimes) 2 *index) 1)) -1)
  527.           ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) 1)))
  528.          *index 0 $inf)
  529.      sp2)
  530.  
  531. (defprop %cosh
  532.      ((%sum) ((mtimes)
  533.           ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  534.           ((mexpt) sp2var ((mtimes) 2 *index)))
  535.          *index 0 $inf)
  536.      sp2)
  537.  
  538. (defprop %tanh
  539.     ((%sum)
  540.      ((mtimes) ((mexpt) 4 *index)
  541.            ((mplus) ((mexpt) 4 *index) -1)
  542.            (($bern) ((mtimes) 2 *index))
  543.            ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1))
  544.            ((mexpt)
  545.             ((mfactorial) ((mtimes) 2 *index))
  546.             -1))
  547.      *index 0 $inf)
  548.     sp2)
  549.  
  550. (defprop %coth
  551.     ((%sum)
  552.      ((mtimes) ((mexpt) 4 *index)
  553.            (($bern) ((mtimes) 2 *index))
  554.            ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  555.            ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1)))
  556.      *index 0 $inf)
  557.     sp2)
  558.  
  559. (defprop %sech 
  560.     ((%sum)
  561.      ((mtimes) (($euler) ((mtimes) 2 *index))
  562.            ((mexpt) ((mfactorial) ((mtimes) 2 *index)) -1)
  563.            ((mexpt) sp2var ((mtimes) 2 *index)))
  564.      *index 0 $inf)
  565.     sp2)
  566.  
  567. (defprop %csch
  568.     ((%sum)
  569.      ((mtimes) -2 ((mplus) ((mexpt) 2 ((mplus) ((mtimes) 2 *index) -1)) -1)
  570.            ((mexpt) ((mfactorial) ((mtimes) *index 2)) -1)
  571.            (($bern) ((mtimes) 2 *index))
  572.            ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) -1)))
  573.      *index 0 $inf)
  574.     sp2)
  575.  
  576. ;arc trigonometric function expansions
  577.  
  578. (defprop %asin
  579.     ((%sum)
  580.      ((mtimes) ((%genfact) ((mplus) ((mtimes) 2 *index) -1) *index 2)
  581.            ((mexpt) ((%genfact) ((mtimes) 2 *index) *index 2) -1)
  582.               ((mexpt) ((mplus) ((mtimes) 2 *index) 1) -1)
  583.            ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) 1)))
  584.      *index 0 $inf)
  585.     sp2)
  586.  
  587. (defprop %atan
  588.     ((%sum)
  589.      ((mtimes) ((mexpt) -1 *index)
  590.            ((mexpt) ((mplus) ((mtimes) 2 *index) 1) -1)
  591.            ((mexpt) sp2var ((mplus) ((mtimes) 2 *index) 1)))
  592.      *index 0 $inf)
  593.     sp2)
  594.